/*
 *  Copyright (C) 2010 Zubanov Dmitry
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/**
 *
 * @author Zubanov Dmitry aka javadimon, zubanov@gmail.com
 * Omsk, Russia, created 29.05.2010
 * (C) Copyright by Zubanov Dmitry
 */

package org.jssdb.core.josql;

import net.sf.jsqlparser.expression.AllComparisonExpression;
import net.sf.jsqlparser.expression.AnyComparisonExpression;
import net.sf.jsqlparser.expression.CaseExpression;
import net.sf.jsqlparser.expression.DateValue;
import net.sf.jsqlparser.expression.DoubleValue;
import net.sf.jsqlparser.expression.ExpressionVisitor;
import net.sf.jsqlparser.expression.Function;
import net.sf.jsqlparser.expression.InverseExpression;
import net.sf.jsqlparser.expression.JdbcParameter;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.NullValue;
import net.sf.jsqlparser.expression.Parenthesis;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.TimeValue;
import net.sf.jsqlparser.expression.TimestampValue;
import net.sf.jsqlparser.expression.WhenClause;
import net.sf.jsqlparser.expression.operators.arithmetic.Addition;
import net.sf.jsqlparser.expression.operators.arithmetic.Division;
import net.sf.jsqlparser.expression.operators.arithmetic.Multiplication;
import net.sf.jsqlparser.expression.operators.arithmetic.Subtraction;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.Between;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExistsExpression;
import net.sf.jsqlparser.expression.operators.relational.GreaterThan;
import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;
import net.sf.jsqlparser.expression.operators.relational.InExpression;
import net.sf.jsqlparser.expression.operators.relational.IsNullExpression;
import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
import net.sf.jsqlparser.expression.operators.relational.MinorThan;
import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;
import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.select.SubSelect;

public class WhereExpression implements ExpressionVisitor{

    public void visit(NullValue nullValue) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Function function) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(InverseExpression inverseExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(JdbcParameter jdbcParameter) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(DoubleValue doubleValue) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(LongValue longValue) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(DateValue dateValue) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(TimeValue timeValue) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(TimestampValue timestampValue) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Parenthesis parenthesis) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(StringValue stringValue) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Addition addition) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Division division) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Multiplication multiplication) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Subtraction subtraction) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(AndExpression andExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(OrExpression orExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Between between) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(EqualsTo equalsTo) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(GreaterThan greaterThan) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(GreaterThanEquals greaterThanEquals) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(InExpression inExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(IsNullExpression isNullExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(LikeExpression likeExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(MinorThan minorThan) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(MinorThanEquals minorThanEquals) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(NotEqualsTo notEqualsTo) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(Column tableColumn) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(SubSelect subSelect) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(CaseExpression caseExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(WhenClause whenClause) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(ExistsExpression existsExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(AllComparisonExpression allComparisonExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public void visit(AnyComparisonExpression anyComparisonExpression) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

}
